# Standard imports for this module
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime, timedelta, timezone
from typing import Dict, List, Tuple, Optional

# Display settings
pd.set_option('display.max_columns', 15)
pd.set_option('display.width', 200)
plt.style.use('seaborn-v0_8-whitegrid')

# Understanding currency pairs
class CurrencyPair:
    """
    Represents a forex currency pair.
    
    Attributes:
        base: Base currency code
        quote: Quote currency code
        price: Current exchange rate
    """
    
    def __init__(self, base: str, quote: str, price: float):
        self.base = base
        self.quote = quote
        self.price = price
    
    @property
    def symbol(self) -> str:
        """Return the pair symbol."""
        return f"{self.base}/{self.quote}"
    
    def convert(self, amount: float, direction: str = 'base_to_quote') -> float:
        """
        Convert an amount between currencies.
        
        Args:
            amount: Amount to convert
            direction: 'base_to_quote' or 'quote_to_base'
            
        Returns:
            Converted amount
        """
        if direction == 'base_to_quote':
            return amount * self.price
        else:
            return amount / self.price
    
    def __repr__(self) -> str:
        return f"CurrencyPair({self.symbol} = {self.price})"


# Example usage
eur_usd = CurrencyPair('EUR', 'USD', 1.0850)
print(f"Pair: {eur_usd.symbol}")
print(f"Rate: {eur_usd.price}")
print(f"\n10,000 EUR = {eur_usd.convert(10000):.2f} USD")
print(f"10,000 USD = {eur_usd.convert(10000, 'quote_to_base'):.2f} EUR")

# Currency pair classifications
MAJOR_PAIRS = {
    'EUR/USD': {'name': 'Euro', 'nickname': 'Fiber'},
    'GBP/USD': {'name': 'British Pound', 'nickname': 'Cable'},
    'USD/JPY': {'name': 'Japanese Yen', 'nickname': 'Gopher'},
    'USD/CHF': {'name': 'Swiss Franc', 'nickname': 'Swissie'},
    'AUD/USD': {'name': 'Australian Dollar', 'nickname': 'Aussie'},
    'USD/CAD': {'name': 'Canadian Dollar', 'nickname': 'Loonie'},
    'NZD/USD': {'name': 'New Zealand Dollar', 'nickname': 'Kiwi'}
}

MINOR_PAIRS = [
    'EUR/GBP', 'EUR/JPY', 'EUR/CHF', 'EUR/AUD', 'EUR/CAD', 'EUR/NZD',
    'GBP/JPY', 'GBP/CHF', 'GBP/AUD', 'GBP/CAD', 'GBP/NZD',
    'AUD/JPY', 'AUD/CHF', 'AUD/CAD', 'AUD/NZD',
    'CAD/JPY', 'CAD/CHF', 'CHF/JPY', 'NZD/JPY'
]

EXOTIC_PAIRS = [
    'USD/TRY', 'USD/ZAR', 'USD/MXN', 'USD/SGD', 'USD/HKD',
    'USD/SEK', 'USD/NOK', 'USD/DKK', 'USD/PLN', 'USD/HUF',
    'EUR/TRY', 'EUR/ZAR', 'EUR/NOK', 'EUR/SEK', 'EUR/PLN'
]

print("Major Pairs (USD-based, highest liquidity)")
print("=" * 55)
for pair, info in MAJOR_PAIRS.items():
    print(f"{pair:10} - {info['name']:25} ({info['nickname']})")

print(f"\nMinor Pairs (Cross pairs without USD): {len(MINOR_PAIRS)} pairs")
print(f"Exotic Pairs (Emerging market currencies): {len(EXOTIC_PAIRS)} pairs")

def classify_pair(pair: str) -> str:
    """
    Classify a currency pair as major, minor, or exotic.
    
    Args:
        pair: Currency pair symbol (e.g., 'EUR/USD')
        
    Returns:
        Classification string
    """
    pair = pair.upper().replace('_', '/')
    
    if pair in MAJOR_PAIRS:
        return 'Major'
    elif pair in MINOR_PAIRS:
        return 'Minor'
    elif pair in EXOTIC_PAIRS:
        return 'Exotic'
    else:
        # Check if it could be exotic based on currency codes
        exotic_currencies = ['TRY', 'ZAR', 'MXN', 'SGD', 'HKD', 'SEK', 'NOK', 
                           'DKK', 'PLN', 'HUF', 'CZK', 'RUB', 'BRL', 'INR']
        base, quote = pair.split('/')
        if base in exotic_currencies or quote in exotic_currencies:
            return 'Exotic'
        return 'Unknown'

# Test classification
test_pairs = ['EUR/USD', 'GBP/JPY', 'USD/TRY', 'AUD/NZD', 'EUR/ZAR']
print("Pair Classification")
print("=" * 30)
for pair in test_pairs:
    print(f"{pair:12} -> {classify_pair(pair)}")

# Market participants and their characteristics
MARKET_PARTICIPANTS = {
    'Central Banks': {
        'role': 'Monetary policy, currency intervention',
        'volume': 'Massive but infrequent',
        'examples': ['Federal Reserve', 'ECB', 'BOJ', 'BOE']
    },
    'Commercial Banks': {
        'role': 'Interbank trading, customer orders',
        'volume': 'Very high (Tier 1 liquidity)',
        'examples': ['JP Morgan', 'Citi', 'Deutsche Bank', 'UBS']
    },
    'Investment Banks': {
        'role': 'Proprietary trading, market making',
        'volume': 'High',
        'examples': ['Goldman Sachs', 'Morgan Stanley']
    },
    'Hedge Funds': {
        'role': 'Speculative trading, arbitrage',
        'volume': 'High',
        'examples': ['Bridgewater', 'Citadel', 'Renaissance']
    },
    'Corporations': {
        'role': 'Hedging currency exposure',
        'volume': 'Moderate',
        'examples': ['Apple', 'Toyota', 'Nestlé']
    },
    'Retail Traders': {
        'role': 'Speculation',
        'volume': 'Low (5-10% of market)',
        'examples': ['Individual traders via brokers']
    }
}

print("Forex Market Participants")
print("=" * 70)
for participant, info in MARKET_PARTICIPANTS.items():
    print(f"\n{participant}")
    print(f"  Role: {info['role']}")
    print(f"  Volume: {info['volume']}")
    print(f"  Examples: {', '.join(info['examples'])}")

# Market share by participant type (approximate)
participant_shares = {
    'Commercial Banks': 42,
    'Investment Banks': 18,
    'Hedge Funds': 12,
    'Central Banks': 8,
    'Corporations': 8,
    'Retail Traders': 7,
    'Other': 5
}

# Visualize market share
fig, ax = plt.subplots(figsize=(10, 6))

colors = plt.cm.Set3(np.linspace(0, 1, len(participant_shares)))
wedges, texts, autotexts = ax.pie(
    participant_shares.values(),
    labels=participant_shares.keys(),
    autopct='%1.0f%%',
    colors=colors,
    explode=[0.02] * len(participant_shares),
    shadow=True
)

ax.set_title('Forex Market Share by Participant Type', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

class ForexSession:
    """
    Represents a forex trading session.
    
    Attributes:
        name: Session name
        open_hour: Opening hour in UTC
        close_hour: Closing hour in UTC
        key_currencies: Most active currencies during session
    """
    
    def __init__(self, name: str, open_hour: int, close_hour: int, 
                 key_currencies: List[str]):
        self.name = name
        self.open_hour = open_hour
        self.close_hour = close_hour
        self.key_currencies = key_currencies
    
    def is_open(self, utc_hour: int) -> bool:
        """Check if the session is open at a given UTC hour."""
        if self.open_hour < self.close_hour:
            return self.open_hour <= utc_hour < self.close_hour
        else:  # Crosses midnight
            return utc_hour >= self.open_hour or utc_hour < self.close_hour
    
    def hours_until_open(self, utc_hour: int) -> int:
        """Calculate hours until session opens."""
        if self.is_open(utc_hour):
            return 0
        hours = (self.open_hour - utc_hour) % 24
        return hours


# Define the four major sessions
SESSIONS = {
    'Sydney': ForexSession('Sydney', 21, 6, ['AUD', 'NZD']),
    'Tokyo': ForexSession('Tokyo', 0, 9, ['JPY', 'AUD']),
    'London': ForexSession('London', 8, 17, ['EUR', 'GBP', 'CHF']),
    'New York': ForexSession('New York', 13, 22, ['USD', 'CAD'])
}

# Check current session status
current_utc_hour = datetime.now(timezone.utc).hour
print(f"Current UTC Hour: {current_utc_hour:02d}:00")
print("\nSession Status")
print("=" * 50)
for name, session in SESSIONS.items():
    status = "OPEN" if session.is_open(current_utc_hour) else "CLOSED"
    hours_until = session.hours_until_open(current_utc_hour)
    hours_info = f"" if hours_until == 0 else f" (opens in {hours_until}h)"
    currencies = ', '.join(session.key_currencies)
    print(f"{name:12} {status:6}{hours_info:15} [{currencies}]")

# Visualize session overlaps
def plot_forex_sessions():
    """Create a visual representation of forex trading sessions."""
    fig, ax = plt.subplots(figsize=(14, 5))
    
    sessions_data = [
        ('Sydney', 21, 6, '#2ecc71'),
        ('Tokyo', 0, 9, '#e74c3c'),
        ('London', 8, 17, '#3498db'),
        ('New York', 13, 22, '#9b59b6')
    ]
    
    for i, (name, start, end, color) in enumerate(sessions_data):
        y = i * 0.8
        
        if start > end:  # Crosses midnight
            # Draw first part (start to midnight)
            ax.barh(y, 24 - start, left=start, height=0.6, color=color, alpha=0.7)
            # Draw second part (midnight to end)
            ax.barh(y, end, left=0, height=0.6, color=color, alpha=0.7)
        else:
            ax.barh(y, end - start, left=start, height=0.6, color=color, alpha=0.7)
        
        ax.text(-0.5, y, name, ha='right', va='center', fontweight='bold', fontsize=11)
    
    # Highlight overlaps
    ax.axvspan(8, 9, alpha=0.2, color='orange', label='Tokyo-London Overlap')
    ax.axvspan(13, 17, alpha=0.2, color='red', label='London-NY Overlap')
    
    ax.set_xlim(-4, 24)
    ax.set_ylim(-0.5, 3.5)
    ax.set_xlabel('UTC Hour', fontsize=12)
    ax.set_xticks(range(0, 25, 2))
    ax.set_xticklabels([f'{h:02d}:00' for h in range(0, 25, 2)])
    ax.set_yticks([])
    ax.set_title('Forex Trading Sessions (UTC)', fontsize=14, fontweight='bold')
    ax.legend(loc='upper right')
    ax.grid(True, axis='x', alpha=0.3)
    
    plt.tight_layout()
    plt.show()

plot_forex_sessions()

# Session volatility analysis
def estimate_session_volatility(pair: str, session: str) -> dict:
    """
    Estimate typical volatility for a pair during a session.
    
    Args:
        pair: Currency pair
        session: Trading session name
        
    Returns:
        Dictionary with volatility estimates
    """
    # Volatility multipliers (base = London session)
    session_multipliers = {
        'Sydney': 0.5,
        'Tokyo': 0.7,
        'London': 1.0,
        'New York': 0.9,
        'London-NY Overlap': 1.2
    }
    
    # Base pip ranges per pair (approximate daily range in London)
    base_ranges = {
        'EUR/USD': 60,
        'GBP/USD': 90,
        'USD/JPY': 70,
        'AUD/USD': 65,
        'USD/CAD': 70
    }
    
    pair = pair.upper().replace('_', '/')
    base_range = base_ranges.get(pair, 75)
    multiplier = session_multipliers.get(session, 1.0)
    
    session_range = base_range * multiplier
    
    return {
        'pair': pair,
        'session': session,
        'expected_range_pips': round(session_range),
        'volatility_level': 'High' if multiplier >= 1.0 else 'Medium' if multiplier >= 0.7 else 'Low'
    }

# Compare volatility across sessions
print("EUR/USD Volatility by Session")
print("=" * 50)
for session in ['Sydney', 'Tokyo', 'London', 'New York', 'London-NY Overlap']:
    vol = estimate_session_volatility('EUR/USD', session)
    print(f"{session:20} {vol['expected_range_pips']:3} pips ({vol['volatility_level']})")

class PipCalculator:
    """
    Calculator for pip values and position sizing.
    
    Attributes:
        pair: Currency pair
        account_currency: Account denomination currency
    """
    
    # Pip sizes for different pair types
    STANDARD_PIP = 0.0001
    JPY_PIP = 0.01
    
    # Lot sizes
    LOT_SIZES = {
        'standard': 100_000,
        'mini': 10_000,
        'micro': 1_000,
        'nano': 100
    }
    
    def __init__(self, pair: str, account_currency: str = 'USD'):
        self.pair = pair.upper().replace('_', '/')
        self.account_currency = account_currency.upper()
        self.base, self.quote = self.pair.split('/')
    
    @property
    def pip_size(self) -> float:
        """Get the pip size for this pair."""
        return self.JPY_PIP if 'JPY' in self.pair else self.STANDARD_PIP
    
    def pip_value(self, lot_size: float = 1.0, exchange_rate: Optional[float] = None) -> float:
        """
        Calculate pip value in account currency.
        
        Args:
            lot_size: Position size in lots
            exchange_rate: Current exchange rate (for conversion if needed)
            
        Returns:
            Pip value in account currency
        """
        units = lot_size * self.LOT_SIZES['standard']
        pip_value_in_quote = units * self.pip_size
        
        # If quote currency matches account currency, we're done
        if self.quote == self.account_currency:
            return pip_value_in_quote
        
        # Otherwise, need to convert (simplified - assumes USD account)
        if exchange_rate is not None:
            if self.account_currency == 'USD' and self.base == 'USD':
                return pip_value_in_quote / exchange_rate
        
        return pip_value_in_quote
    
    def pips_to_price(self, pips: int) -> float:
        """Convert pips to price movement."""
        return pips * self.pip_size
    
    def price_to_pips(self, price_change: float) -> float:
        """Convert price movement to pips."""
        return price_change / self.pip_size


# Example calculations
calc = PipCalculator('EUR/USD')
print("EUR/USD Pip Calculations")
print("=" * 40)
print(f"Pip size: {calc.pip_size}")
print(f"1 standard lot pip value: ${calc.pip_value(1.0):.2f}")
print(f"1 mini lot pip value: ${calc.pip_value(0.1):.2f}")
print(f"1 micro lot pip value: ${calc.pip_value(0.01):.2f}")
print(f"\n50 pips = {calc.pips_to_price(50):.4f} price movement")

print("\n" + "=" * 40)
calc_jpy = PipCalculator('USD/JPY')
print(f"USD/JPY pip size: {calc_jpy.pip_size}")
print(f"50 pips = {calc_jpy.pips_to_price(50):.2f} price movement")

# Pip value comparison across pairs
def compare_pip_values(pairs: List[str], lot_size: float = 1.0) -> pd.DataFrame:
    """
    Compare pip values across different currency pairs.
    
    Args:
        pairs: List of currency pairs
        lot_size: Position size in lots
        
    Returns:
        DataFrame with pip value comparison
    """
    results = []
    
    for pair in pairs:
        calc = PipCalculator(pair)
        pip_val = calc.pip_value(lot_size)
        
        results.append({
            'Pair': pair,
            'Pip Size': calc.pip_size,
            f'Pip Value ({lot_size} lot)': f'${pip_val:.2f}',
            '10 Pip Move': f'${pip_val * 10:.2f}',
            '50 Pip Move': f'${pip_val * 50:.2f}'
        })
    
    return pd.DataFrame(results)

# Compare major pairs
pairs = ['EUR/USD', 'GBP/USD', 'USD/JPY', 'AUD/USD', 'USD/CAD']
print("Pip Value Comparison (1 Standard Lot)")
print("=" * 70)
print(compare_pip_values(pairs).to_string(index=False))

class ForexMarketAnalyzer:
    """
    Comprehensive forex market analyzer.
    
    Combines pair analysis, session tracking, and pip calculations
    into a unified interface for forex market analysis.
    
    Attributes:
        account_currency: Base currency for calculations
        account_balance: Trading account balance
    """
    
    MAJOR_CURRENCIES = ['USD', 'EUR', 'GBP', 'JPY', 'CHF', 'AUD', 'CAD', 'NZD']
    
    SESSIONS = {
        'Sydney': {'open': 21, 'close': 6, 'currencies': ['AUD', 'NZD']},
        'Tokyo': {'open': 0, 'close': 9, 'currencies': ['JPY', 'AUD', 'NZD']},
        'London': {'open': 8, 'close': 17, 'currencies': ['EUR', 'GBP', 'CHF']},
        'New York': {'open': 13, 'close': 22, 'currencies': ['USD', 'CAD']}
    }
    
    TYPICAL_SPREADS = {'Major': 1.0, 'Minor': 3.0, 'Exotic': 15.0}
    
    def __init__(self, account_currency: str = 'USD', account_balance: float = 10000):
        self.account_currency = account_currency.upper()
        self.account_balance = account_balance
        self.watched_pairs = {}
    
    # ==================== Pair Analysis ====================
    
    def add_pair(self, pair: str, bid: float = None, ask: float = None):
        """
        Add a currency pair to the watchlist.
        
        Args:
            pair: Currency pair symbol
            bid: Current bid price
            ask: Current ask price
        """
        pair = self._normalize_pair(pair)
        base, quote = pair.split('/')
        
        self.watched_pairs[pair] = {
            'base': base,
            'quote': quote,
            'bid': bid,
            'ask': ask,
            'classification': self._classify_pair(pair)
        }
    
    def _normalize_pair(self, pair: str) -> str:
        """Normalize pair format to BASE/QUOTE."""
        return pair.upper().replace('_', '/')
    
    def _classify_pair(self, pair: str) -> str:
        """Classify pair as Major, Minor, or Exotic."""
        base, quote = pair.split('/')
        has_usd = 'USD' in pair
        both_major = base in self.MAJOR_CURRENCIES and quote in self.MAJOR_CURRENCIES
        
        if has_usd and both_major:
            return 'Major'
        elif both_major:
            return 'Minor'
        return 'Exotic'
    
    def get_pair_info(self, pair: str) -> dict:
        """Get comprehensive information about a pair."""
        pair = self._normalize_pair(pair)
        
        if pair not in self.watched_pairs:
            self.add_pair(pair)
        
        info = self.watched_pairs[pair].copy()
        info['pip_size'] = self._get_pip_size(pair)
        info['pip_value_std_lot'] = self._calculate_pip_value(pair, 1.0)
        info['typical_spread'] = self.TYPICAL_SPREADS[info['classification']]
        
        if info['bid'] and info['ask']:
            info['current_spread'] = (info['ask'] - info['bid']) / info['pip_size']
        
        return info
    
    # ==================== Pip Calculations ====================
    
    def _get_pip_size(self, pair: str) -> float:
        """Get pip size for a pair."""
        return 0.01 if 'JPY' in pair else 0.0001
    
    def _calculate_pip_value(self, pair: str, lots: float) -> float:
        """Calculate pip value in account currency."""
        pip_size = self._get_pip_size(pair)
        units = lots * 100_000
        return units * pip_size
    
    def calculate_pips(self, pair: str, entry: float, exit: float) -> float:
        """Calculate pip difference between two prices."""
        pair = self._normalize_pair(pair)
        pip_size = self._get_pip_size(pair)
        return (exit - entry) / pip_size
    
    def calculate_pnl(
        self,
        pair: str,
        entry: float,
        exit: float,
        lots: float,
        direction: str = 'long'
    ) -> dict:
        """Calculate P&L for a trade."""
        pair = self._normalize_pair(pair)
        
        # Calculate pip change
        pips = self.calculate_pips(pair, entry, exit)
        if direction.lower() == 'short':
            pips = -pips
        
        # Calculate monetary P&L
        pip_value = self._calculate_pip_value(pair, lots)
        pnl = pips * pip_value / 100_000 * lots * 100_000
        
        # Simplified: pip_value for 1 lot * pips
        pip_value_per_lot = self._calculate_pip_value(pair, 1.0)
        pnl = pips * (pip_value_per_lot / (1 / self._get_pip_size(pair))) * lots
        
        # Correct calculation
        pnl = pips * lots * 10  # $10 per pip per lot for most pairs
        
        return {
            'pair': pair,
            'direction': direction,
            'entry': entry,
            'exit': exit,
            'lots': lots,
            'pips': round(pips, 1),
            'pnl': round(pnl, 2)
        }
    
    # ==================== Position Sizing ====================
    
    def calculate_position_size(
        self,
        pair: str,
        stop_loss_pips: int,
        risk_percent: float = 1.0
    ) -> dict:
        """
        Calculate position size based on risk parameters.
        
        Args:
            pair: Currency pair
            stop_loss_pips: Stop loss distance in pips
            risk_percent: Percentage of account to risk
            
        Returns:
            Position sizing details
        """
        pair = self._normalize_pair(pair)
        
        # Calculate risk amount
        risk_amount = self.account_balance * (risk_percent / 100)
        
        # Pip value per standard lot (approximately $10 for most pairs)
        pip_value_per_lot = 10  # Simplified
        
        # Risk per lot = pip_value * stop_loss_pips
        risk_per_lot = pip_value_per_lot * stop_loss_pips
        
        # Position size
        lots = risk_amount / risk_per_lot
        
        return {
            'pair': pair,
            'account_balance': self.account_balance,
            'risk_percent': risk_percent,
            'risk_amount': round(risk_amount, 2),
            'stop_loss_pips': stop_loss_pips,
            'position_lots': round(lots, 2),
            'position_units': int(lots * 100_000)
        }
    
    # ==================== Session Analysis ====================
    
    def _is_session_open(self, session_name: str, utc_hour: int) -> bool:
        """Check if a session is open."""
        session = self.SESSIONS.get(session_name)
        if not session:
            return False
        
        open_h, close_h = session['open'], session['close']
        if open_h > close_h:
            return utc_hour >= open_h or utc_hour < close_h
        return open_h <= utc_hour < close_h
    
    def get_active_sessions(self, utc_hour: int = None) -> List[str]:
        """Get currently active sessions."""
        if utc_hour is None:
            utc_hour = datetime.now(timezone.utc).hour
        
        return [
            name for name in self.SESSIONS
            if self._is_session_open(name, utc_hour)
        ]
    
    def analyze_trading_conditions(self, pair: str, utc_hour: int = None) -> dict:
        """
        Analyze current trading conditions for a pair.
        
        Args:
            pair: Currency pair
            utc_hour: Hour in UTC (default: current)
            
        Returns:
            Trading condition analysis
        """
        if utc_hour is None:
            utc_hour = datetime.now(timezone.utc).hour
        
        pair = self._normalize_pair(pair)
        base, quote = pair.split('/')
        
        # Get active sessions
        active = self.get_active_sessions(utc_hour)
        
        # Find relevant sessions for this pair
        relevant = []
        for session_name, info in self.SESSIONS.items():
            if base in info['currencies'] or quote in info['currencies']:
                relevant.append(session_name)
        
        # Determine trading condition
        matching = [s for s in relevant if s in active]
        
        if len(matching) >= 2:
            rating = 'Excellent'
            expected_volatility = 'High'
        elif len(matching) == 1:
            rating = 'Good'
            expected_volatility = 'Medium-High'
        elif len(active) > 0:
            rating = 'Fair'
            expected_volatility = 'Medium'
        else:
            rating = 'Poor'
            expected_volatility = 'Low'
        
        return {
            'pair': pair,
            'utc_hour': utc_hour,
            'active_sessions': active,
            'relevant_sessions': relevant,
            'matching_sessions': matching,
            'trading_rating': rating,
            'expected_volatility': expected_volatility
        }
    
    # ==================== Market Overview ====================
    
    def get_market_overview(self, utc_hour: int = None) -> pd.DataFrame:
        """Get overview of all watched pairs."""
        if utc_hour is None:
            utc_hour = datetime.now(timezone.utc).hour
        
        results = []
        for pair in self.watched_pairs:
            info = self.get_pair_info(pair)
            conditions = self.analyze_trading_conditions(pair, utc_hour)
            
            results.append({
                'Pair': pair,
                'Type': info['classification'],
                'Pip Value': f"${info['pip_value_std_lot']:.2f}",
                'Typ. Spread': f"{info['typical_spread']} pips",
                'Rating': conditions['trading_rating'],
                'Volatility': conditions['expected_volatility']
            })
        
        return pd.DataFrame(results)
    
    def print_summary(self):
        """Print a comprehensive market summary."""
        utc_hour = datetime.now(timezone.utc).hour
        active_sessions = self.get_active_sessions(utc_hour)
        
        print("\n" + "=" * 70)
        print("FOREX MARKET ANALYZER SUMMARY")
        print("=" * 70)
        print(f"\nAccount Balance: ${self.account_balance:,.2f}")
        print(f"Current UTC Time: {utc_hour:02d}:00")
        print(f"Active Sessions: {', '.join(active_sessions) if active_sessions else 'None'}")
        
        if self.watched_pairs:
            print("\n" + "-" * 70)
            print("WATCHED PAIRS")
            print("-" * 70)
            overview = self.get_market_overview(utc_hour)
            print(overview.to_string(index=False))
        
        print("\n" + "=" * 70)